home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / i / internet / software / netstsr / envacc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-10  |  14.8 KB  |  453 lines
  1. /************************************************************************/
  2. /*                                                                      */
  3. /*    news.c                                                            */
  4. /*                                                                      */
  5. /*    Durch bloßes Ändern der Extension im Dateinamen, läßt sich Pro-   */
  6. /*    gramm als normale GEM-Anwendung oder aber als Accessory betrei-   */
  7. /*    ben.                                                              */
  8. /*    Das Programm zeigt in einem Fenster die aktuellen Neuigkeiten an. */
  9. /*                                                                      */
  10. /*    Copyright (c)  FORTEC/pm 1989                                     */
  11. /*                                                                      */
  12. /************************************************************************/
  13.  
  14. /* -------------------------------------------------------------------- */
  15. /*    Headerdateien einbinden.                                          */
  16. /* -------------------------------------------------------------------- */
  17.  
  18. #include <aes.h>
  19. #include <stdio.h>
  20. #include <tos.h>
  21. #include <vdi.h>
  22. #include <string.h>
  23. #include <cookie.h>
  24. #include "ownfunc.h"
  25.  
  26.  
  27. #define TEXTSIZE 2048L
  28. #define WINW     300
  29. #define WINH     200
  30.  
  31. /* -------------------------------------------------------------------- */
  32. /*    Extern definierte globale Variablen.                              */
  33. /* -------------------------------------------------------------------- */
  34.                                     /* Mittels dieser Variablen kann    */
  35. extern int _app;                    /* das Programm feststellen, ob es  */
  36.                                     /* als Accessory oder normale App-  */
  37.                                     /* likation gestartet wurde.        */
  38. /* -------------------------------------------------------------------- */
  39. /*    Globale Variablen.                                                */
  40. /* -------------------------------------------------------------------- */
  41.  
  42. int  whandle;                       /* Handle für geöffnetes Fenster.   */
  43. char title[] = "NetEnvironment";    /* Titelzeile des Fensters.         */
  44. int  gl_wchar,                      /* Größe und Breite eines Buchsta-  */
  45.      gl_hchar,                      /* ben (wichtig falls mit unter-    */
  46.      gl_wbox,                       /* schiedlichen Bildschirmauflö-    */
  47.      gl_hbox;                       /* sungen gearbeitet wird) bzw.     */
  48.                                     /* einer Box.                       */
  49. int  phys_handle,                   /* Handles für GEM und VDI.         */
  50.      handle;
  51. int  max_x,                         /* Maximale Größe der Arbeitsfläche */
  52.      max_y;
  53. int  appl_id,                       /* Identifikationsnummer des Prog.  */
  54.      menu_id;                       /* Id.-nummer im Menü 'Desk'.       */
  55.  
  56. char env_text[TEXTSIZE+1L];
  57. char *env_item[100];
  58. char *p_t;                          /* Pointer auf Newstext             */
  59. long netenv(char *);
  60. TCPSTAT tstat;
  61.  
  62. /* -------------------------------------------------------------------- */
  63. /*    read_text()                                                       */
  64. /*                                                                      */
  65. /*    Lesen der News                                                    */
  66. /* -------------------------------------------------------------------- */
  67.  
  68. char * read_text(void)
  69. {
  70.  int fhandle;
  71.  char *p_l;
  72.  int i;
  73.    
  74.  fhandle=Fopen("\\NETENV.INF",0);
  75.  p_l = env_text-1;
  76.  i=0;
  77.  if(fhandle >0)
  78.  {
  79.    /* Zeichen einzeln einlesen */
  80.    p_l = env_text;
  81.    env_item[0] = p_l;
  82.    while (1L == Fread(fhandle, 1L, p_l) && (p_l-env_text < TEXTSIZE))
  83.    {
  84.      switch (*p_l)
  85.      {
  86.      case 13:/* CR ausfiltern */
  87.        break;
  88.      case 10:/* LF nach NULL */
  89.        *p_l++ = 0;                        
  90.        env_item[++i] = p_l;
  91.        break;
  92.      default:
  93.        p_l += 1;
  94.        break;
  95.      }
  96.      if(i>=((sizeof(env_item)/sizeof(env_item[0]))-1)) break;
  97.    }
  98.    Fclose(fhandle);
  99.  }
  100.  env_item[i] = NULL;
  101.  if(p_l-env_text <= 0L) sprintf(env_text,"NETENV.INF not found!");
  102.  else env_text[p_l-env_text]=0;
  103.  
  104.  return env_text;
  105. }
  106.  
  107. /* -------------------------------------------------------------------- */
  108. /*    open_window()                                                     */
  109. /*                                                                      */
  110. /*    Öffnen eines Fensters                                             */
  111. /* -------------------------------------------------------------------- */
  112.  
  113. void open_window( void )
  114. {
  115.    if(whandle <= 0)
  116.    {
  117.       whandle = wind_create( NAME|CLOSER|MOVER, 0, 0, max_x + 1, max_y + 1 );
  118.       if( whandle <= 0 )
  119.          return;
  120.  
  121.       wind_set ( whandle, WF_NAME, title );
  122.       wind_open( whandle, 100, 100, WINW, WINH );
  123.    }
  124.    else
  125.       wind_set( whandle, WF_TOP );
  126. }
  127.  
  128. /* -------------------------------------------------------------------- */
  129. /*    min()                                                             */
  130. /*                                                                      */
  131. /*    Minimum zweier Zahlen berechnen.                                  */
  132. /* -------------------------------------------------------------------- */
  133.  
  134. int min( int a, int b)
  135. {
  136.    if( a > b )
  137.       return( b );
  138.    else
  139.       return( a );
  140. }
  141.  
  142. /* -------------------------------------------------------------------- */
  143. /*    max()                                                             */
  144. /*                                                                      */
  145. /*    Maximum zweier Zahlen bestimmen.                                  */
  146. /* -------------------------------------------------------------------- */
  147.  
  148. int max( int a, int b)
  149. {
  150.    if( a < b )
  151.       return( b );
  152.    else
  153.       return( a );
  154. }
  155.  
  156. /* -------------------------------------------------------------------- */
  157. /*    rc_intersect()                                                    */
  158. /*                                                                      */
  159. /*    Schnittfläche zweier Rechtecke berechnen.                         */
  160. /* -------------------------------------------------------------------- */
  161.  
  162. int rc_intersect(GRECT *r1, GRECT *r2)
  163. {
  164.    int xl, yu, xr, yd;                      /* left, upper, right, down */
  165.  
  166.    xl      = max( r1->g_x, r2->g_x );
  167.    yu      = max( r1->g_y, r2->g_y );
  168.    xr      = min( r1->g_x + r1->g_w, r2->g_x + r2->g_w );
  169.    yd      = min( r1->g_y + r1->g_h, r2->g_y + r2->g_h );
  170.  
  171.    r2->g_x = xl;
  172.    r2->g_y = yu;
  173.    r2->g_w = xr - xl;
  174.    r2->g_h = yd - yu;
  175.  
  176.    return( r2->g_w > 0 && r2->g_h > 0 );
  177. }
  178.  
  179. /* -------------------------------------------------------------------- */
  180. /*    mouse_on()                                                        */
  181. /*                                                                      */
  182. /*    Mauszeiger anschalten.                                            */
  183. /* -------------------------------------------------------------------- */
  184.  
  185. void mouse_on(void)
  186.  
  187. {
  188.    graf_mouse( M_ON, (void *)0 );
  189. }
  190.  
  191. /* -------------------------------------------------------------------- */
  192. /*    mouse_off()                                                       */
  193. /*                                                                      */
  194. /*    Mauszeiger ausschalten.                                           */
  195. /* -------------------------------------------------------------------- */
  196.  
  197. void mouse_off(void)
  198. {
  199.    graf_mouse( M_OFF, (void *)0 );
  200. }
  201.  
  202. /* -------------------------------------------------------------------- */
  203. /*    redraw_window()                                                   */
  204. /*                                                                      */
  205. /*    Fensterinhalt neu zeichnen, nachdem er zuvor aus irgendeinem      */
  206. /*    Grunde zerstört wurde, oder weil das Fenster neu geöffnet wurde.  */
  207. /* -------------------------------------------------------------------- */
  208.  
  209. void redraw_window( int all )
  210. {
  211.    GRECT   box,
  212.            work;
  213.    int     clip[4];
  214.    char    *p_l;
  215.    int     line,dum;
  216.       
  217.    if( whandle <= 0 )                  /* Wenn kein Fenster auf ist,    */
  218.       return;                          /* braucht auch nicht gezeichnet */
  219.                                        /* zu werden.                    */
  220.  
  221.    if(all)
  222.    {
  223.  
  224.       mouse_off();
  225.  
  226.       vsf_color( handle, 0 );                       /* set white fill   */
  227.       vswr_mode( handle, 1 );                       /* set replace mode */
  228.       vst_height( handle, 4, &dum,&dum,&dum,&dum);  /* set small font   */
  229.  
  230.       wind_get( whandle, WF_WORKXYWH, &work.g_x, &work.g_y, &work.g_w,
  231.                 &work.g_h );
  232.       wind_get( whandle, WF_FIRSTXYWH, &box.g_x, &box.g_y, &box.g_w,
  233.                 &box.g_h );
  234.       work.g_w = min( work.g_w, max_x - work.g_x + 1 );
  235.       work.g_h = min( work.g_h, max_y - work.g_y + 1 );
  236.       
  237.       while ( box.g_w > 0 && box.g_h > 0 )
  238.       {
  239.          if( rc_intersect( &work, &box ) )
  240.          {
  241.             clip[0] = box.g_x;
  242.             clip[1] = box.g_y;
  243.             clip[2] = box.g_x + box.g_w - 1;
  244.             clip[3] = box.g_y + box.g_h - 1;
  245.  
  246.             vs_clip( handle, 1, clip );
  247.             if( all )
  248.                vr_recfl( handle, clip );
  249.               /* fill rectangle */
  250.             line=0;
  251.             p_l=p_t;
  252.             while(*p_l)
  253.             {
  254.               v_gtext( handle, work.g_x, work.g_y + 15 + (line*10), p_l);
  255.               line++;
  256.               p_l=p_l+strlen(p_l)+1;
  257.             }
  258.          }
  259.          wind_get( whandle, WF_NEXTXYWH, &box.g_x, &box.g_y, &box.g_w,
  260.                    &box.g_h );
  261.       }
  262.       mouse_on();
  263.    }
  264. }
  265.  
  266. /* -------------------------------------------------------------------- */
  267. /*    handle_message()                                                  */
  268. /*                                                                      */
  269. /*    Auswertung der Ereignisse des Multi-Events bezüglich des Message- */
  270. /*    buffers.                                                          */
  271. /* -------------------------------------------------------------------- */
  272.  
  273. int handle_message( int pipe[8] )
  274. {
  275.    switch ( pipe[0] )
  276.    {
  277.       case WM_REDRAW:
  278.          redraw_window(1);
  279.       break;
  280.  
  281.       case WM_TOPPED:
  282.          wind_set( whandle, WF_TOP );
  283.       break;
  284.  
  285.       case WM_CLOSED:
  286.          if( pipe[3] == whandle )
  287.          {
  288.             wind_close( whandle );
  289.             wind_delete( whandle );
  290.             whandle = 0;
  291.          }
  292.          if( _app )
  293.             return(1);
  294.       break;
  295.  
  296.       case WM_MOVED:
  297.       case WM_SIZED:
  298.          if( pipe[3] == whandle )
  299.             wind_set( whandle, WF_CURRXYWH,  pipe[4], pipe[5],
  300.                       pipe[6], pipe[7] );
  301.       break;
  302.  
  303.       case AC_OPEN:
  304.          if( pipe[4] == menu_id )
  305.          {
  306.              p_t = read_text();
  307.             open_window();
  308.          }
  309.       break;
  310.  
  311.       case AC_CLOSE:
  312.          if( pipe[3] == menu_id )
  313.             whandle = 0;
  314.       break;
  315.    }
  316.    return(0);
  317. }
  318.  
  319. /* -------------------------------------------------------------------- */
  320. /*    event_loop()                                                      */
  321. /*                                                                      */
  322. /*    Die Multi-Event-Schleife.                                         */
  323. /* -------------------------------------------------------------------- */
  324.  
  325. static void event_loop( void )
  326. {
  327.    int x, y,
  328.        kstate,
  329.        key,
  330.        clicks,
  331.        event,
  332.        state;
  333.    int pipe[8];
  334.    int quit;
  335.  
  336.    quit = 0;
  337.    do
  338.    {
  339.       event = evnt_multi( MU_MESAG | MU_TIMER,
  340.                           2, 0x1, 1,
  341.                           0, 0, 0, 0, 0,
  342.                           0, 0, 0, 0, 0,
  343.                           pipe,
  344.                           10, 0,
  345.                           &x, &y, &state, &kstate, &key, &clicks );
  346.  
  347.  
  348.       if( event & MU_MESAG)
  349.       {
  350.          wind_update(BEG_UPDATE);
  351.          quit = handle_message( pipe );
  352.          wind_update(END_UPDATE);
  353.       }
  354.       if( event & MU_TIMER)
  355.       {
  356.          tcp_stat(0,&tstat);
  357.       }
  358.       
  359.  
  360.  
  361.    }
  362.    while (!quit);
  363. }
  364.  
  365. /* -------------------------------------------------------------------- */
  366. /*    main()                                                            */
  367. /*                                                                      */
  368. /*    Kernstück des Programms.                                          */
  369. /* -------------------------------------------------------------------- */
  370.  
  371. int main( void )
  372. {
  373.    int i;
  374.    int work_in[11];
  375.    int work_out[57];
  376.  
  377.    extern char *read_text(void);
  378.    
  379.    /* ----------------------------------------------------------------- */
  380.    /* Initialization                                                    */
  381.    /* ----------------------------------------------------------------- */
  382.  
  383.    appl_id = appl_init();
  384.    if( appl_id != -1 )
  385.    {
  386.       for (i = 0; i < 10; i++)
  387.          work_in[i]  = 1;
  388.          work_in[10] = 2;
  389.          phys_handle = graf_handle( &gl_wchar, &gl_hchar, &gl_wbox,
  390.                                      &gl_hbox );
  391.       handle = phys_handle;
  392.       v_opnvwk( work_in, &handle, work_out );
  393.       if( handle != 0 )
  394.       {
  395.          max_x = work_out[0];
  396.          max_y = work_out[1];
  397.          p_t=read_text();
  398.          if( !_app )
  399.          {
  400.              if(env_item[0]) add_cookie(NETENVCOOKIE,(long)netenv);
  401.             menu_id = menu_register( appl_id, "  NetEnv" );
  402.          }
  403.          else
  404.          {
  405.             graf_mouse( 0, (void*)0 );
  406.             open_window();
  407.          }
  408.  
  409.    /* ----------------------------------------------------------------- */
  410.    /* Event Loop                                                        */
  411.    /* ----------------------------------------------------------------- */
  412.  
  413.          event_loop();
  414.  
  415.    /* ----------------------------------------------------------------- */
  416.    /* Deinitialization                                                  */
  417.    /* ----------------------------------------------------------------- */
  418.  
  419.          v_clsvwk( handle );
  420.       }
  421.       appl_exit();
  422.    }
  423.    return(0);
  424. }
  425.  
  426. long netenv(char *item)
  427. {
  428. register char **envdata;
  429. register char *data;
  430.  
  431.     if(!item) return(0L);
  432.     envdata = env_item;
  433.     while(*envdata)
  434.     {
  435.         if(!strnicmp(*envdata,item,strlen(item)))
  436.         {
  437.             data = *envdata;
  438.             while(*data && *data++ != '=');
  439.             while(*data && *data == ' ') data++;
  440.             if(!*data) return(0L);
  441.             return((long)data);
  442.         }
  443.         envdata++;
  444.     }
  445.     return(0L);
  446. }
  447.  
  448.  
  449.  
  450. /* -------------------------------------------------------------------- */
  451. /*    End of ENVACC.C                                                   */
  452. /* -------------------------------------------------------------------- */
  453.